package abstraction;

import java.io.File;
import java.io.IOException;
import java.sql.Connection;

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Observable;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import abstraction.ImportException;

/**
 * 
 * @author Pocman
 *
 */
public class Cours extends Observable {
	
	private int moduleCourant;
	private int groupeCourant;
	private int evaluationCourante;
	private String etudiantCourant;
	private boolean validationPossible;
	

	public static final Integer CHANGEMENT_MODULE_COURANT = new Integer(1);
	public static final Integer CHANGEMENT_GROUPE_COURANT = new Integer(2);	
	public static final Integer CHANGEMENT_EVALUATION_COURANTE = new Integer(3);
	public static final Integer CHANGEMENT_VALIDATION = new Integer(4);
	public static final Integer CHANGEMENT_ETUDIANT_COURANT = new Integer(9);
	public static final Integer CHANGEMENT_MODULES = new Integer(5);
	public static final Integer CHANGEMENT_GROUPES = new Integer(6);
	public static final Integer CHANGEMENT_EVALUATIONS = new Integer(7);
	public static final Integer CHANGEMENT_ETUDIANTS = new Integer(8);
	public static final Integer CHANGEMENT_NOTES = new Integer(10);
	
	private Connection connexion;
	
	/**Constructeur qui ouvre la base de donnée et positionne le curseurs à -1
	 * 
	 * @throws SQLException
	 */
	public Cours() throws SQLException {
		this.moduleCourant = -1;
		this.groupeCourant = -1;
		this.etudiantCourant = null;
		this.evaluationCourante = -1;

		BDCours bdcours = new BDCours();
		bdcours.connexionBD();
		this.connexion = bdcours.getConnexion();
		
		this.setCompteurModule();
		this.setCompteurGroupe();
		this.setCompteurEvaluation();
		
	}
	
	/**Met à jour l'indices de la classe Groupe 
	 * 
	 * @throws SQLException
	 */
	public void setCompteurGroupe() throws SQLException{
		Statement s = connexion.createStatement();
		ResultSet rs = s.executeQuery("SELECT count(*) FROM groupe");
		rs.next();
		Groupe.setCompteurGroupe(rs.getInt(1));
	}
	/**Met à jour l'indices de la classe Module
	 * 
	 * @throws SQLException
	 */
	public void setCompteurModule() throws SQLException{
		Statement s = connexion.createStatement();
		ResultSet rs = s.executeQuery("SELECT count(*) FROM Module");
		rs.next();
		Module.setCompteurModule(rs.getInt(1));
	}
	
	/**Met à jour l'indices de la classe Evaluation
	 * 
	 * @throws SQLException
	 */
	public void setCompteurEvaluation() throws SQLException{
		Statement s = connexion.createStatement();
		ResultSet rs = s.executeQuery("SELECT count(*) FROM Evaluation");
		rs.next();
		Evaluation.setCompteur_evaluation(rs.getInt(1));
	}
	
	/**Gestion de l'affichage des modules dans la JListe module
	 * 
	 * @return
	 */
	public Vector<String> getModuleNames() {
		Vector<String> modules = new Vector<String>();
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT nom FROM MODULE order by nom asc");
			while (rs.next()) {
				modules.add(rs.getString("nom").trim());
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return modules;
	}
	
	/**Gestion de l'affichage des groupes dans la JListe groupes
	 * 
	 * @param id_module
	 * @return
	 */
	public Vector<String> getGroupeNames(int id_module){//nom du module
		Vector<String> groupes = new Vector<String>();
		try {
			Statement s = connexion.createStatement();
			String requete = "SELECT nom FROM GROUPE";
			if (id_module != -1)
				requete += " WHERE id_module=" + id_module + " order by nom asc";
			ResultSet rs = s.executeQuery(requete);
			while (rs.next()) {
				groupes.add("" + rs.getString("nom").trim());
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return groupes;
	}
	
	/**Gestion de l'affichage des évaluations dans la JListe évaluation
	 * 
	 * @param id_module
	 * @return
	 */
	public Vector<String> getEvaluationNames(int id_module){//nom du module
		Vector<String> evaluations = new Vector<String>();
		try {
			Statement s = connexion.createStatement();
			String requete = "SELECT nom FROM Evaluation";
			if (id_module != -1)
				requete += " WHERE id_module=" + id_module + ";";
			ResultSet rs = s.executeQuery(requete);
			while (rs.next()) {
				evaluations.add("" + rs.getString("nom").trim());
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return evaluations;
	}
	
	/**Gestion de l'affichage des étudiants dans la JListe étudiant
	 * 
	 * @return
	 */
	public Vector<String> getEtudiants(){
		Vector<String> etudiants = new Vector<String>();
		Vector<Etudiant> e = this.findEtudiants();
		
		boolean validation = e.size() > 0;
		
		for(int i = 0; i < e.size() ; i ++){
			Etudiant tmp = e.get(i);
			Note n = this.findNote(tmp.getEmail());
			if(this.evaluationCourante != -1 && n != null){
				String note = new String("" + n.getNote());
				if(n.estDefinitive())
					note = note + " def";
				etudiants.add("" + tmp.getNom() + " " + tmp.getPrenom() + " " + tmp.getEmail() + " " + note);
			}else{
				validation = false;
				etudiants.add("" + tmp.getNom() + " " + tmp.getPrenom() + " " + tmp.getEmail() + " " );
				}
		}
		this.setValidationPossible(validation);		
		return etudiants;
	}

	public int getModuleCourant() {
		return moduleCourant;
	}

	public void setModuleCourant(int selectedModule) {
		
			this.moduleCourant = selectedModule;
			this.setGroupeCourant(-1);
			this.setEvaluationCourante(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_MODULE_COURANT);
		
	}

	public int getGroupeCourant() {
		return groupeCourant;
	}

	public void setGroupeCourant(int groupeCourant) {
		if (this.groupeCourant != groupeCourant) {
			this.groupeCourant = groupeCourant;
			this.setChanged();
			this.notifyObservers(CHANGEMENT_GROUPE_COURANT);
		}
	}

	public int getEvaluationCourante(){
		return this.evaluationCourante;
	}
	
	public void setEvaluationCourante(int selectedEvaluation) {
			this.evaluationCourante = selectedEvaluation;
			this.setChanged();
			this.notifyObservers(CHANGEMENT_EVALUATION_COURANTE);		
	}
	
	public String getEtudiantCourant(){
		return this.etudiantCourant;
		
	}
	
	public void setEtudiantCourant(String selectedStudent) {
			this.etudiantCourant = selectedStudent;
			this.setChanged();
			this.notifyObservers(CHANGEMENT_ETUDIANT_COURANT);
	}
	
	/**Trouve le module de nom "nom" dans la base de donnée
	 * 
	 * @param nom
	 * @return le module ou null si le module n'existe pas dans la base de donnée
	 */
	public Module findModule(String nom) {
		Module m = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM MODULE WHERE nom='"
					+ nom + "'");
			while(rs.next())
			m = new Module(rs.getInt("id_module"), rs.getString("nom").trim(), rs.getString(
					"responsable").trim());
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return m;
	}
	
	/**Trouve le module grâce à son identifiant dans la base de donnée
	 * 
	 * @param id_module
	 * @return le module ou null si le module n'existe pas dans la base de donnée
	 */
	public Module findModule(int id_module) {
		Module m = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM MODULE WHERE id_module="
					+ id_module + ";");
			rs.next();
			m = new Module(rs.getInt("id_module"), rs.getString("nom").trim(), rs.getString(
					"responsable").trim());
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return m;
	}

	/**Ajoute ou modifie le module m dans la base de donnée
	 * 
	 * @param m
	 * @param creation permet de déterminer si on ajoute ou modifie le module
	 * @throws SQLException
	 */
	public void saveModule(Module m, boolean creation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = 0;
		if (creation){
			result = s.executeUpdate("INSERT INTO MODULE VALUES (" + m.getId_module() + ",'"
					+ m.getNom().trim() + "','" + m.getResponsable().trim() + "')");
			this.setModuleCourant(m.getId_module());
		}
		else {
			result = s.executeUpdate("UPDATE MODULE SET nom='" + m.getNom().trim()
					+ "', responsable='" + m.getResponsable().trim() + "' WHERE id_module="
					+ this.getModuleCourant() + ";");
			this.setModuleCourant(m.getId_module());
		}
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(CHANGEMENT_MODULES);
		}
	}
		
	/**Supprime le module de la base de donnée
	 * 
	 * @param id_module
	 * @throws SQLException
	 */
	public void deleteModule(int id_module) throws SQLException {
		Statement s = connexion.createStatement();
		int result = s
				.executeUpdate("DELETE FROM MODULE WHERE id_module=" + id_module + ";");
		if (result > 0) {
			this.setModuleCourant(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_MODULES);
		}

	}

	/**Trouve un groupe dans la base de donnée en fonction du module et du nom du groupe
	 * 
	 * @param id_module
	 * @param nom
	 * @return retour le groupe ou null si le groupe n'existe pas
	 */
	public Groupe findGroupe(int id_module, String nom) {
		Groupe groupe = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM GROUPE WHERE id_module="
					+ id_module + " AND nom ='" + nom + "';");
			while(rs.next())
				groupe = new Groupe(rs.getInt("id_groupe"), id_module, rs.getString("nom").trim(), rs.getString("encadrant").trim());
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return groupe;
	}
	
	/**Trouve un groupe dans la base de donnée en fonction de son identifiant
	 * 
	 * @param id_module
	 * @param nom
	 * @return retour le groupe ou null si le groupe n'existe pas
	 */
	public Groupe findGroupe(int id_groupe) {
		Groupe groupe = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM GROUPE WHERE id_groupe=" + id_groupe + ";");
			while(rs.next())
				groupe = new Groupe(rs.getInt("id_groupe"), this.getModuleCourant(), rs.getString("nom").trim(), rs.getString("encadrant").trim());
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return groupe;
	}
	
	/**Permet de trouver les groupes dans lesquels est un étudiant
	 * 
	 * @param etudiant
	 * @return
	 */
	public Vector<Groupe> getGroupes(Etudiant etudiant){
		Vector<Groupe> groupes = new Vector<Groupe>();
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM GROUPE, repartition_groupe where repartition_groupe.email = '" + etudiant.getEmail() + "' and repartition_groupe.id_groupe = groupe.id_groupe;");
			while(rs.next()){
				groupes.add(
						new Groupe(rs.getInt("id_groupe"),  rs.getInt("id_module"), rs.getString("nom").trim(), rs.getString("encadrant").trim() ));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return groupes;
	}

	/**Permet de trouver les groupes d'un module
	 * 
	 * @param id_module
	 * @return
	 */
	public Vector<Groupe> getGroupes(int id_module){
		Vector<Groupe> groupes = new Vector<Groupe>();
		ResultSet rs = null;
		try {
			Statement s = connexion.createStatement();
			if(id_module == -1){
				rs = s.executeQuery("SELECT * FROM GROUPE;");
				
			}
			else{
				rs = s.executeQuery("SELECT * FROM GROUPE where groupe.id_module ="+ id_module + ");");
			}
			while(rs.next()){
				groupes.add(
						new Groupe(rs.getInt("id_groupe"),  rs.getInt("id_module"), rs.getString("nom").trim(), rs.getString("encadrant").trim() ));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return groupes;
	}
	
	/**Ajoute ou modifie le groupe g dans la base de donnée
	 * 
	 * @param g
	 * @param creation
	 * @throws SQLException
	 */
	public void saveGroupe(Groupe g, boolean creation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = 0;
		if (creation){
			result = s.executeUpdate("INSERT INTO GROUPE VALUES (" + g.getId_groupe()+ "," + g.getId_module()+ ",'" + g.getNom()+ "','"	+ g.getEncadrant() + "')");
			this.setGroupeCourant(g.getId_groupe());			
		}
			else {
			result = s.executeUpdate("UPDATE GROUPE SET nom='" + g.getNom() + "', encadrant='" + g.getEncadrant() + "' WHERE id_groupe=" + this.getGroupeCourant());
			this.setGroupeCourant(g.getId_groupe());
		}
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(CHANGEMENT_GROUPES);
		}

	}
	
	/**Supprime le groupe de la base de donnée 
	 * 
	 * @param id_module
	 * @param nom_groupe
	 * @throws SQLException
	 */
	public void deleteGroupe(int id_module, String nom_groupe) throws SQLException {

		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM GROUPE WHERE id_module="
				+ id_module + " AND nom='" + nom_groupe +"';");
		if (result > 0) {
			this.setGroupeCourant(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_GROUPES);
		}

	}
	
	/**Supprime le groupe de la base de donnée 
	 * 
	 * @param id_groupe
	 * @throws SQLException
	 */
	public void deleteGroupe(int id_groupe) throws SQLException {

		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM GROUPE WHERE id_groupe="
				+ id_groupe + ";");
		if (result > 0) {
			this.setGroupeCourant(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_GROUPES);
		}

	}
	
	/**Trouve un étudiant dans la base de donnée
	 * 
	 * @param email
	 * @return
	 */
	public Etudiant findEtudiant(String email) {
		Etudiant etudiant = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM Etudiant WHERE email='"
					+ email +"';");
			while(rs.next())
			etudiant = new Etudiant(rs.getString("nom").trim(), rs.getString("prenom").trim(), rs.getString(
					"email").trim());
			} catch (SQLException e) {
			e.printStackTrace();
		}
		return etudiant;
	}
	
	/**Trouve les étudiants en fonction du module, des groupes et évaluations courantes
	 * 
	 * @return
	 */
	public Vector<Etudiant> findEtudiants(){
		Vector<Etudiant> etudiants = new Vector<Etudiant>();
		try {
			Statement s = connexion.createStatement();
			ResultSet rs; 
			if(this.moduleCourant == -1)
				rs = s.executeQuery("SELECT * FROM Etudiant;");
			else if(this.groupeCourant == -1)
				rs = s.executeQuery("SELECT * FROM Etudiant, groupe, repartition_groupe where groupe.id_module ="+ this.moduleCourant+" and repartition_groupe.id_groupe = groupe.id_groupe and etudiant.email = repartition_groupe.email ;");
			else
				rs = s.executeQuery("SELECT * FROM Etudiant, repartition_groupe where repartition_groupe.id_groupe =" + this.getGroupeCourant() +" and etudiant.email = repartition_groupe.email;");
				
			while(rs.next()){
				etudiants.add(new Etudiant(rs.getString("nom").trim(), rs.getString("prenom").trim(), rs.getString(
					"email").trim()));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return etudiants;
	}
	
	/**Ajoute ou modifie l'étudiant e dans la base de donnée
	 * 
	 * @param e
	 * @param creation
	 * @throws SQLException
	 */
	public void saveEtudiant(Etudiant e, boolean creation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = 0;
		if (creation){
			result = s.executeUpdate("INSERT INTO Etudiant VALUES ('"
					+ e.getNom() + "','" + e.getPrenom() + "','" + e.getEmail() + "')");
			this.setEtudiantCourant(e.getEmail());
		}
		else {
			result = s.executeUpdate("UPDATE Etudiant SET nom='" + e.getNom()
					+ "', prenom='" + e.getPrenom() + "' WHERE email='"
					+ this.getEtudiantCourant() + "'");
			this.setEtudiantCourant(e.getEmail());
		}
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(CHANGEMENT_ETUDIANTS);
		}
	}
	
	/**Supprime l'étudiant de la base de donnée
	 * 
	 * @param email
	 * @throws SQLException
	 */
	public void deleteEtudiant(String email) throws SQLException {
		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM Etudiant WHERE email='"
				+ email + "';");
		if (result > 0) {
			this.setEtudiantCourant(null);
			this.setChanged();
			this.notifyObservers(Cours.CHANGEMENT_ETUDIANTS);
		}
	}
	
	/**Trouve une évaluation dans la base de donnée
	 * 
	 * @param id_evaluation
	 * @return
	 */
	public Evaluation findEvaluation(int id_evaluation){
		Evaluation evaluation = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM Evaluation WHERE id_evaluation="
					+ id_evaluation + ";");
			
			while(rs.next())	{		
				evaluation = new Evaluation(rs.getInt("id_evaluation"), rs.getString("nom").trim(), rs.getInt("id_module"), rs.getString("date").trim(), rs.getString("mode_evaluation").trim());
			}
			} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return evaluation;
	}
	
	/**Trouve une évaluation dans la base de donnée
	 * 
	 * @param id_module
	 * @param nom
	 * @return
	 */
	public Evaluation findEvaluation(int id_module, String nom){
		Evaluation evaluation = null;
		try {
			Statement s = connexion.createStatement();
			ResultSet rs = s.executeQuery("SELECT * FROM Evaluation WHERE id_module="
					+ id_module + " and nom ='"+ nom +"';");
			
			while(rs.next())	{		
				evaluation = new Evaluation(rs.getInt("id_evaluation"), rs.getString("nom").trim(), rs.getInt("id_module"), rs.getString("date").trim(), rs.getString("mode_evaluation").trim());
			}
			} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return evaluation;
	}
	
	/**Ajoute ou modifie l'évaluation e dans la base de donnée
	 * 
	 * @param e
	 * @param creation
	 * @throws SQLException
	 */
	public void saveEvaluation(Evaluation e, boolean creation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = 0;
		if (creation){
			result = s.executeUpdate("INSERT INTO Evaluation VALUES ("+ e.getId_evaluation() +","
					+ e.getId_module() + ",'" + e.getNom() + "','" + e.getDate()+ "','"+ e.getMode_evaluation() + "');");
	
			this.setEvaluationCourante(e.getId_evaluation());
		}
		else {
			result = s.executeUpdate("UPDATE Evaluation SET id_module=" + e.getId_module()
					+ ", nom='" + e.getNom() + "', date ='" + e.getDate()  + "', mode_evaluation='"+ e.getMode_evaluation() +"' WHERE id_evaluation="
					+ this.getEvaluationCourante() + ";");
			this.setEvaluationCourante(e.getId_evaluation());
		}
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(Cours.CHANGEMENT_EVALUATIONS);
		}
	}
	
	/**Supprime l'évaluation de la base de donnée
	 * 
	 * @param id_module
	 * @param nom_evaluation
	 * @throws SQLException
	 */
	public void deleteEvaluation(int id_module, String nom_evaluation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM Evaluation WHERE id_module="
				+ id_module + " and nom = '" +  nom_evaluation +"';");
		if (result > 0) {
			this.setEvaluationCourante(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_EVALUATIONS);
		}
	}
	
	/**Supprime l'évaluation de la base de donnée
	 * 
	 * @param id_evaluation
	 * @throws SQLException
	 */
	public void deleteEvaluation(int id_evaluation) throws SQLException {
		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM Evaluation WHERE id_evaluation="+ id_evaluation+";");
		if (result > 0) {
			this.setEvaluationCourante(-1);
			this.setChanged();
			this.notifyObservers(CHANGEMENT_EVALUATIONS);
		}
	}
	
	/**Trouve une note dans la base de donnée en fonction de l'évaluation courante
	 * 
	 * @param email
	 * @return
	 */
	public Note findNote(String email) {
		Note note = null;
		if (this.evaluationCourante != -1) {
			try {
				Statement s = connexion.createStatement();
				ResultSet rs = s
						.executeQuery("SELECT * FROM Note WHERE email ='"
								+ email + "' and id_evaluation="
								+ this.evaluationCourante + ";");

				while(rs.next())
				note = new Note(rs.getInt("id_evaluation"),
						rs.getString("email").trim(), rs.getInt("note"),
						rs.getString("date_correction").trim(), rs.getString("correcteur").trim(), rs.getBoolean("estdefinitive"));
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return note;
	}

	/**Ajoute ou modifie la note n dans la base de donnée
	 * 
	 * @param n
	 * @param creation
	 * @throws SQLException
	 */
	public void saveNote(Note n, boolean creation) throws SQLException {
		Statement s = connexion.createStatement();
		
		int result = 0;
		if (creation){
			result = s.executeUpdate("INSERT INTO Note VALUES ("+ n.getId_evaluation() +",'"+ n.getDate_correction() +"','"+ n.getEmail() +"',"
					+ n.getNote() + ",'" + n.getCorrecteur() + "','"+ n.estDefinitive() +"')");

		}
		else {
			result = s.executeUpdate("UPDATE Note SET date_correction='" + n.getDate_correction()
					+ "', note =" + n.getNote() + ", correcteur='"+ n.getCorrecteur()+"', estdefinitive = '"+ n.estDefinitive() +"' WHERE email='"
					+ n.getEmail() +"' and id_evaluation=" + n.getId_evaluation() + ";");
		}
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(CHANGEMENT_NOTES);
		}
	}
	
	/**Supprime la note de la base de donnée
	 * La note est identifiée par un identifiant d'évaluation et l'email d'un étudiant
	 * 
	 * @param id_evaluation
	 * @param email
	 * @throws SQLException
	 */
	public void deleteNote(int id_evaluation, String email) throws SQLException {
		Statement s = connexion.createStatement();
		int result = s.executeUpdate("DELETE FROM Note WHERE Note.id_evaluation = " + id_evaluation + " and email = '" + email + "';");
		if (result > 0) {
			this.setChanged();
			this.notifyObservers(CHANGEMENT_NOTES);
		}
	}

	/**Ajoute un étudiant dans un groupe
	 * 
	 * @param id_groupe
	 * @param email
	 */
	public void ajouterEtudiantDansGroupe(int id_groupe, String email){
		int result = 0;
		try {
			Statement s = connexion.createStatement();			
			result = s.executeUpdate("INSERT into REPARTITION_GROUPE values ('" + email + "'," + id_groupe + ")" );
			if(result > 0){
				this.setChanged();
				this.notifyObservers(Cours.CHANGEMENT_ETUDIANTS);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
	}
	
	/**Supprimer un étudiant d'un groupe
	 * 	
	 * @param email
	 */
	public void supprimerEtudiantDansGroupe(String email){
		int result = 0;
		try {
			Statement s = connexion.createStatement();
			result = s.executeUpdate("delete from REPARTITION_GROUPE where email = '" + email + "';");
			if(result > 0){
				this.setChanged();
				this.notifyObservers(Cours.CHANGEMENT_ETUDIANTS);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	
	/*pour l'importation du fichier XML, on ne peut rajouter des notes que si un module est sélectionné dans 
	la liste. Un correcteur peut donc transmettre dans un meme fichier les notes de plusieurs élèves pour 
	plusieurs évaluations mais d'un meme module. Un exemple de fichier XML est donné en annexe, si on selectionne le module "maths".
	*/
	
	
	/**Permet l'importation depuis un fichier XML
	 * 
	 * @param file
	 * @return
	 * @throws ParserConfigurationException
	 * @throws SAXException
	 * @throws IOException
	 * @throws ImportException
	 * @throws SQLException
	 * @throws ParseException
	 */
	public boolean importFile(File file) throws ParserConfigurationException, SAXException, IOException, ImportException, SQLException, ParseException {
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = factory.newDocumentBuilder();
		Document document= builder.parse(file);
		
		if (!document.hasChildNodes())
			throw new ImportException();
		NodeList correcteurs = document.getChildNodes();
		
		if (correcteurs.getLength()!=1) 
			throw new ImportException();
		
		Element correcteurCourant = (Element) document.getFirstChild();
		String nomCorrecteur = correcteurCourant.getAttribute("nom");
		NodeList listeNotes = correcteurCourant.getElementsByTagName("note");
		
		if (listeNotes.getLength()==0)
			throw new ImportException();
		

		for (int i=0; i<listeNotes.getLength(); i++) {
			String emailEleve = ((Element) listeNotes.item(i)).getAttribute("email");
			String date = ((Element) listeNotes.item(i)).getAttribute("date");
			Double note =Double.parseDouble(((Element) listeNotes.item(i)).getAttribute("note"));
			String nomEval=((Element) listeNotes.item(i)).getAttribute("nomEval");
			int id_module=this.getModuleCourant();
			int id_eval=findEvaluation(id_module,nomEval).getId_evaluation();
			
			Note n=new Note(id_eval,emailEleve,note,date,nomCorrecteur,false);
			saveNote(n,true);//création d'une nouvelle note à partir des données du fichier XML

		}
		
			this.setChanged();
			this.notifyObservers(CHANGEMENT_NOTES);

		return true;
		
	}
	
	public boolean validationPossible() {
		return validationPossible;
	}

	public void setValidationPossible(boolean validationPossible) {
		this.validationPossible = validationPossible;
		this.setChanged();
		this.notifyObservers(Cours.CHANGEMENT_VALIDATION);
	
	}
}
